extends Node2D
class_name leadinggd;
@export var min_speed: float = 885.0;    # 最低安全速度
@export var max_speed: float = 915.0;   # 最高安全速度
@onready var min_label: Label = $数据UI/最低速度
@onready var max_label: Label = $数据UI/最高速度
@onready var current_label: Label = $数据UI/当前速度
@onready var pressed: AudioStreamPlayer = $音乐音效/点击音效
@onready var 游戏结束_失败_: AudioStreamPlayer = $"音乐音效/游戏结束（失败）"
@onready var 游戏结束_通关_: AudioStreamPlayer = $"音乐音效/游戏结束（通关）"
@onready var 超速警告: AudioStreamPlayer = $音乐音效/超速警告

@onready var uipro: CanvasLayer = $关卡介绍
@onready var 失败ui: CanvasLayer = $失败UI
@onready var 成功ui: CanvasLayer = $成功UI

@onready var tile_map_layer: TileMapLayer = $TileMapLayer
var TileSetNumber = 0;
var TileRoad = Vector2i(0, 19);
@onready var player: CharacterBody2D = $邮车;
var tile_length = 710.0;  # 基础间隔（710）
var last_trigger_x = 0.0;  # 上次触发生成的玩家X坐标
var initial_setup_done = false;  # 标记是否完成初始化
@onready var target_area: Area2D = $检查点
var area_spawn_chance = 0.4;  # 生成Area2D的概率（40%）
var spawn_offset = 1700.0;  # 玩家前方生成距离
var target_area_max = 10;  # 目标数量
var current_area_count = 0;  # 当前已生成的数量计数器
@onready var final_area: Area2D = $终点
var final_area_spawned = false

# 新增：记录最后一个检查点的世界坐标（默认初始值为玩家初始位置）
var last_target_world_pos: Vector2 = Vector2.ZERO

#@onready var goal_count: Label = $邮车/Camera2D/关卡目标
var count=0;#投递邮件数量

##游戏结束相关
var speed_flag=false; #速度是否超过区间
var speed_flags_count=0;#速度超过区间次数
#var end_victory=false;#游戏通关
var end_defeat=false;#游戏失败

# 新增：速度超限计时器（控制2秒倒计时）
var speed_over_timer: Timer = Timer.new()
# 新增：标记是否已记录过本次超限（避免重复计数）
var has_recorded_overrun = false

# 新增：获取“完成情况”Label节点（根据你的节点结构，路径是$数据UI/完成情况）
@onready var complete_label: Label = $数据UI/完成情况

# 新增：瓦片地图相对于玩家的Y轴偏移量（核心变量，可直接修改调整）
# 正数 = 瓦片在玩家上方；负数 = 瓦片在玩家下方；0 = 与玩家Y轴对齐
var tile_y_offset = 0.0;  # 示例：改为 300.0 则瓦片在玩家上方300像素

# 新增：终点与最后一个检查点的距离（可调整）
var final_area_offset = 1500.0;

func _ready() -> void:
	print("脚本载入成功");
	last_trigger_x = player.position.x;
	# 初始化最后一个检查点位置为玩家初始位置（避免空值）
	last_target_world_pos = player.global_position;
	# 初始化生成7个瓦片（会自动应用Y轴偏移）
	generate_road_tiles();
	initial_setup_done = true;
	# 初始化完成情况文本
	update_complete_label();
	
	# 初始化速度超限计时器
	speed_over_timer.wait_time = 2.0  # 倒计时2秒
	speed_over_timer.one_shot = true  # 单次触发（计时结束后自动停止）
	add_child(speed_over_timer)  # 将计时器添加为子节点
	# 绑定计时器超时信号（计时结束触发游戏失败）
	speed_over_timer.timeout.connect(_on_speed_over_timeout)
	# 初始化UI状态（隐藏失败/成功UI）
	失败ui.visible = false
	成功ui.visible = false
	get_tree().paused=true
	pass;

func _pressed():
	pressed.play();

# 新增：更新“完成情况”文本的函数
func UI_pro():

	uipro.visible=false;
	
func update_complete_label() -> void:
	# 计算完成比例（格式为“已完成：X/Y”，或“X/Y”）
	complete_label.text = "%d/%d" % [player.player_mailed, target_area_max];
	min_label.text = "%d" % min_speed;
	max_label.text = "%d" % max_speed;
	current_label.text = "%d" % player.current_speed;

# 核心函数：生成7个瓦片+ 清除旧瓦片（已修改：添加Y轴偏移）
func generate_road_tiles() -> void:
	# 1. 清除所有旧瓦片（避免堆积）
	tile_map_layer.clear();
	
	# 2. 获取玩家当前世界坐标（作为基准位置）
	var player_world_pos = player.global_position;
	
	# 3. 瓦片X轴偏移量（保持原逻辑，新增Y轴偏移应用）
	var offsets = [
		-tile_length*2,  # 玩家后方1420
		-tile_length,    # 玩家后方710
		0.0,             # 玩家当前位置
		tile_length,     # 玩家前方710
		tile_length*2,   # 玩家前方1420
		tile_length*3,   # 玩家前方2130
		tile_length*4    # 玩家前方2840
	];
	
	# 4. 逐个生成瓦片（关键修改：添加tile_y_offset到Y轴）
	for offset_x in offsets:
		# 计算当前瓦片的世界坐标：X轴偏移 + Y轴偏移（tile_y_offset）
		var target_world_pos = Vector2(
			player_world_pos.x + offset_x,
			player_world_pos.y + tile_y_offset  # 应用Y轴偏移
		);
		# 转换为瓦片网格坐标（Godot 4.x 标准流程）
		var tile_pos = world_to_tile_grid(target_world_pos);
		# 生成瓦片
		tile_map_layer.set_cell(tile_pos, TileSetNumber, TileRoad);
		# 可选：打印日志验证瓦片位置（含Y轴偏移）
		#print("生成瓦片：世界坐标（", target_world_pos.x, ", ", target_world_pos.y, "）→ 网格坐标（", tile_pos, "）");
	pass;

# 辅助函数：世界坐标 → 瓦片网格坐标（保持原逻辑，Y轴偏移已在生成时应用）
func world_to_tile_grid(world_pos: Vector2) -> Vector2i:
	var local_pos = tile_map_layer.to_local(world_pos);  # 世界→局部
	var grid_pos = tile_map_layer.local_to_map(local_pos);  # 局部→网格
	grid_pos.y = 0;  # 固定Y轴网格坐标（按你的马路高度调整，不影响世界坐标偏移）
	return grid_pos;

func _process(delta: float) -> void:
	# 游戏结束后不再执行逻辑
	if end_defeat:
		return;
	# 初始化完成后，才检测移动触发和速度监控
	if not initial_setup_done:
		return;
	# -------------- 新增：速度监控逻辑 --------------
	monitor_player_speed()
	# -------------- 原有逻辑 --------------
	# 玩家每向右移动710单位，触发一次（仅正向移动）
	if player.position.x - last_trigger_x >= tile_length:
		# 生成新的7个瓦片（自动应用最新的Y轴偏移）
		generate_road_tiles();
		# 更新上次触发坐标（累计叠加，支持持续触发）
		last_trigger_x += tile_length;
		#print("玩家移动710单位，已更新瓦片组");
		try_duplicate_area();
	# 实时更新完成情况文本（也可以在count变化时单独调用，这里是实时更新）
	update_complete_label();
	if player.player_mailed == target_area_max:
		$"成功UI/Control/Panel/二星".visible=true;
	if not speed_flags_count == 0:
		$"成功UI/Control/Panel/三星".visible=false;
		pass;

# 新增：速度监控核心函数
func monitor_player_speed() -> void:
	# 获取玩家当前速度（假设player节点的current_speed是实际移动速度）
	var current_speed = player.current_speed
	
	# 1. 速度超出区间（低于最小值或高于最大值）
	if current_speed < min_speed or current_speed > max_speed:
		# 设置超限标记为true
		
		speed_flag = true
		
		# 仅在首次超限且未记录时，累计超限次数（避免同一超限过程重复计数）
		if not has_recorded_overrun:
			speed_flags_count += 1
			has_recorded_overrun = true
			print("速度超限！当前超限次数：", speed_flags_count)
		
		# 启动计时器（如果未运行）
		if speed_over_timer.is_stopped():
			超速警告.play();
			speed_over_timer.start()
			print("速度超限，开始2秒倒计时...")
	
	# 2. 速度回到正常区间
	else:
		超速警告.stop()
		# 重置超限标记
		speed_flag = false
		# 重置计数标记（允许下次超限重新计数）
		has_recorded_overrun = false
		# 停止计时器并清零
		if not speed_over_timer.is_stopped():
			speed_over_timer.stop()
			print("速度恢复正常，倒计时已重置")

# 新增：速度超限计时结束回调（游戏失败）
func _on_speed_over_timeout() -> void:
	if not end_defeat and speed_flag:  # 确保是在超限状态下触发
		end_defeat = true
		游戏结束_失败_.play();
		print("⚠️  游戏失败！速度超限持续2秒")
		# 暂停游戏（暂停整个场景树的进程）
		get_tree().paused = true
		游戏结束_失败_.play();
		# 显示失败UI
		失败ui.visible = true
# 重新开始当前场景（核心函数）
func goto_select() -> void:
	get_tree().paused = false
	pressed.play();
	await get_tree().create_timer(0.5).timeout  # 等待0.56秒
	get_tree().change_scene_to_file("res://场景/选关界面.tscn");

func restart_current_scene() -> void:
	pressed.play();
	await get_tree().create_timer(0.5).timeout  # 等待0.56秒
	# 1. 取消场景暂停（避免重载后仍处于暂停状态）
	get_tree().paused = false
	
	# 2. 获取当前场景的路径（自动适配当前场景）
	var current_scene_path = get_tree().current_scene.scene_file_path
	
	# 3. 重载场景（关键：销毁当前场景并重新加载）
	get_tree().change_scene_to_file(current_scene_path)
	
	print("✅ 场景已重新开始！")
# 新增：通关逻辑函数
func _on_victory() -> void:
	游戏结束_通关_.play();
	print("🎉 游戏通关！")
	# 暂停游戏
	get_tree().paused = true
	# 显示成功UI
	成功ui.visible = true

# 新功能：复制Area2D到玩家前方1000单位（可选：让检查点/终点跟随瓦片Y轴位置）
func try_duplicate_area() -> void:
	# 游戏结束后不再生成检查点
	if end_defeat:
		return;
	
	# 检查模板Area2D是否存在
	if not target_area:
		print("警告：未找到作为模板的Area2D节点，请检查节点名称");
		return;
	
	# 情况1：未达上限，正常生成target_area
	if current_area_count < target_area_max:
		# 40%概率触发复制
		if randf() < area_spawn_chance:
			var new_area = target_area.duplicate();
			new_area.name = "Area2D_Spawned_" + str(randi_range(1000, 9999));
			# 关键修改：检查点Y轴位置跟随瓦片偏移（与瓦片在同一高度）
			var target_pos = Vector2(
				player.global_position.x + spawn_offset,
				player.global_position.y + tile_y_offset  # 应用瓦片Y轴偏移
			);
			new_area.global_position = target_pos;
			new_area.visible = true;
			add_child(new_area);
			
			# 关键修改：更新最后一个检查点的位置（每次生成检查点都记录）
			last_target_world_pos = target_pos;
			
			current_area_count += 1;
			print("成功复制检查点！位置：", target_pos, " 节点名称：", new_area.name, 
				  " 当前数量：", current_area_count);
			# 3秒后自动删除该Area2D
			new_area.call_deferred("queue_free_in", 3.0);
		else:
			pass;
	
	# 情况2：已达上限，生成final_area（终点在最后一个检查点后方1500像素）
	elif current_area_count >= target_area_max and not final_area_spawned:
		if not final_area:
			print("警告：未找到作为模板的final_area节点，请检查节点名称");
			return;
		
		var new_final_area = final_area.duplicate();
		new_final_area.name = "FinalArea_Spawned";
		# 核心修改：终点坐标 = 最后一个检查点X + 1500，Y轴跟随瓦片偏移
		var final_target_pos = Vector2(
			last_target_world_pos.x + final_area_offset,  # 最后一个检查点后方1500
			last_target_world_pos.y  # 与最后一个检查点Y轴一致（已包含瓦片偏移）
		);
		new_final_area.global_position = final_target_pos;
		new_final_area.visible = true;
		add_child(new_final_area);
		
		final_area_spawned = true;
		print("✅ 检查点已达生成上限（", target_area_max, "个），生成终点节点！");
		print("最后一个检查点位置：", last_target_world_pos.x);
		print("终点位置：", final_target_pos.x);
	
	else:
		print("已达检查点生成上限，且终点已生成，停止生成");
	pass;

# 扩展函数：延迟删除节点
func queue_free_in(delay: float) -> void:
	await get_tree().create_timer(delay).timeout;
	queue_free();
	print("自动清理Area2D：", name);
func back_menu():
	pressed.play();
	await get_tree().create_timer(0.5).timeout
	get_tree().paused=false;
	get_tree().change_scene_to_file("res://场景/主菜单.tscn")
